package com.bart.a_data_type

/**
  * Created by BartG on 2018/9/9.
  * -------------------------------------------------
  *             控制结构和函数
  * -------------------------------------------------
  *
  * ----------》》》 if ... else
  * java中表达式有值语句没有值，但是scala中都有值
  * eg：
  *   val a = if(1 > 0) 1 else "2"
  *  如果两个返回值的类型不一样的话，scala会自动的封装为一个Any类型的对象
  *  val b = if(1 > 0) 1 else ()
  *  可以返回一个 Unit 类型的对象即 () 相当于 java 中的 void
  *
  * ----------》》》 while 和 do ... while
  * while 和 do ... while 循环返回值都是 Unit 即 void 类型
  *
  * 注意：
  *   scala 并没有提供 break 和 continue 语句来退出循环，如果需要break功能可以通过下面方法：
  *   1. 使用 Boolean 类型的控制变量
  *   2. 使用嵌套函数，从函数中 return
  *   3. 使用 Break 对象的 break 方法
  *
  * ----------》》》 for 表达式
  * for 表达式：
  *   （for 表达式被赋予了很多功能）
  *   1. 多重循环：
  *     scala> for(i <- 1 to 3;j <- 5 to 8) print(i +"_"+ j +",")
        1_5,1_6,1_7,1_8,2_5,2_6,2_7,2_8,3_5,3_6,3_7,3_8,
        其中 i <- x to y "<-" 表示的是生成器表达式，意味着i的值取值为1~3，后面的j也是一个循环

  *   2. 循环中使用变量：
  *     scala> for(i <- 1 to 3;j=i*i) print(i +"_"+ j +",")
        1_1,2_4,3_9,
        其中 j 的值是 i*i

     3. for-yield 表达式：
        yield 为for表达式返回一个值，该值是一个集合类型 scala.collection.immutable.IndexedSeq[Int]
        其中的 IndexedSeq[Xxx] Xxx 的类型，视返回值的情况而定
        scala> val k = for(i <- 1 to 3;j=i*i) yield j+i
        k: scala.collection.immutable.IndexedSeq[Int] = Vector(2, 6, 12)

    ----------》》》 函数
    1. 格式：
      def 函数名(形参:参数类型 ... ) [:返回值类型] = 函数体
      eg：
        def abs(x:Int) :Int = if( x < -1) -x else x
        调用： abs(-9)
              res19: Int = 9
              abs(x=-9) 表示调用的时候指定形参的值 x
      变长的参数 :
      def sum(args:Int*) = {
        var result=0
        for(arg <- args) result +=arg
        return result
      }

     ----------》》》 过程
      我们把没有返回值的函数成为过程，没有等号
      eg：
        def box(s:String) {
          println(s)
        }
      或者
        def box(s:String) :Unit = {
          println(s)
        }

     ----------》》》 懒值
      当val被声明为lazy 的时候，他的初始化被推迟，直到我们首次对此取值
      懒值使用注意：
      1. 用于初始化开销比较大的语句
      2. 可以解决循环依赖的问题
      3. 是开发懒数据接口的基础

      object ScalaLazyDemo {
        def init():String = {
          println("huangbo 666")
          return "huangbo"
        }

        def main(args: Array[String]): Unit = {
          lazy val name = init();
          println("666")
          println(name)
        }
      }

     ----------》》》 异常
      用throw关键字抛出一个异常对象，所有的异常对象是Throwable的子类
      throw表达式是有类型的，就是nothing，因为nothing是所有类的子类型
      eg：
        def divide(x:Int, y:Int) :Int = {
          if(y == 0){
            throw new Exception("Divide is zero ")
          } else {
            x /y
          }
        }
      捕获多个异常：
      try{
        process(in)
      }catch{
        case ex: IOException => println(ex)
        case ex: XXException => //...
      }finally{
        in.close()
      }
==================================================
            偏函数
==================================================
  //偏函数是只有一个入参的函数
  def pf: PartialFunction[参数类型,返回值类型] = {
    // ...
  }
  def pf: PartialFunction[String,Int] = {
      case "a" => 97
      case "b" => 99
      case _ => 0
  }

  pf("a")
  *
  */
class _02_Condition {

}
